by Megat Harun Al Rashid bin Megat Ahmad
last updated: April 14, 2016
In Python, a list is considered as an array and operating on each element of the list can be done by accessing them sequentially (e.g. by using $for$ loop function).
In [1]:
# Without Numpy, to get the square root on a list of numbers:
from math import *
x1 = [23,12,45]
for y, z in enumerate(x1):
Ex1 = sqrt(z)
print Ex1
With $NumPy$, elements in the list can be operated directly without the need to access them sequentially. This can be done by transforming the Python list into a $NumPy$ array. Python utilizes this $NumPy$ library as part of its fundamental package for scientific computing. Its major function is to allow easy operations especially on and between homogeneous multi-dimensional arrays. Available features in $NumPy$ can be accessed by importing the library.
In [2]:
from numpy import *
In [3]:
# With Numpy, to get the square root on a list of numbers:
# Creating the Python list
x1 = [23,12,45]
# Transforming the Python list into NumPy array
xnp = array(x1)
# Here we use the available NumPy square root function
Ex1 = sqrt(xnp)
print xnp
print Ex1
Elements of $NumPy$ array are not separated by comma when printed. They are separated only by space.
Performing mathematical operation between arrays requires part of these arrays to be of the same size (e.g. 5 x 10 array can be multiplied with another 5 x 10 array or 5 x 1 array). This will be explored further).
In [4]:
# Array operation on real and imaginary parts to obtain complex conjugate
i = array([12.7,9.3,0.8])
j = array([4.5j,2.7j,3.1j])
print (i + j)*(i + j).conjugate()
Creating an array using $NumPy$ can be done in several ways. In all the following examples, $NumPy$ is imported as $np$. Therefore $NumPy$ can be initially accessed by using $np.\{function\}$. This allows the separate usage of similar wordings $NumPy$ and Python $math$ function like $sqrt$. It is also possible to use $NumPy$ function names directly that have no equivalent in Python functions.
In [5]:
import numpy as np
# Creating a one-dimensional array with sequential integer values
a = np.arange(15)
a
Out[5]:
This create a one dimensional array with 15 elements starting from 0 to 14.
The range and increment of the array elements during array creation can be specified by using the (min, max, add) arguments in the $arange$ function.
In [6]:
'''Below means that the g array is going to contains range of elements with minimum
value of 10 (inclusive of 10) up to a maximum value of 50 (exclusive of or less than 50) and with
an increment of 5'''
g = np.arange(10,50,5)
print g
In [7]:
# To include 50, just set 50 to 51
g = np.arange(10,51,5)
print g
Another useful array creating function is $linspace$ which allows specifying (inclusive both) the minimum and maximum values and the number of array elements.
In [8]:
x = np.linspace(0,2*np.pi,20) # note: np.pi is used instead of just pi
print x
In [9]:
# Checking the inclusivity
print x.min()
print x.max()
print x.size
To create a higher dimensional array, we can use any one of these functions and then use the $reshape$ function. Let reshapes variable a into a two dimensional 3 x 5 array.
In [10]:
# Creating a two-dimensional 3 x 5 array from b
b = a.reshape(3,5)
b
Out[10]:
Shaping a three dimensional 3 x 3 x 3 array:
In [11]:
c = np.arange(27).reshape(3,3,3)
print c
We can check the shape, dimension and size of these arrays, as well as the mean and median of the arrays.
In [12]:
print c.shape # shape of array c
print b.ndim # dimension of array b
print a.size # size of array a or the number of elements in array a
In [13]:
# mean value for the c array
np.mean(c)
Out[13]:
In [14]:
# mean value for b array elements in each column
np.mean(b, axis=0)
Out[14]:
In [15]:
# mean value for b array elements in each row
np.mean(b, axis=1)
Out[15]:
In [16]:
# average value for a all array elements
np.average(a)
Out[16]:
In [17]:
# sum values for c array elements in axis 2
np.sum(c,axis=2)
Out[17]:
Earlier in this tutorial, a simple mathematical operations for complex number array has been shown. $NumPy$ arrays can only be operated with each other when the arrays are of the same size and dimension.
In [18]:
# Finding the sin^2(x) + cos^2(x) (trigonometric identity)
np.sin(x)**2 + np.cos(x)**2 # note: np.sin and np.cos are used instead of just sin and cos
Out[18]:
In [19]:
z = np.linspace(1,5.347,20)
In [20]:
x*z # note: arrays of the same size and dimension
Out[20]:
In [21]:
a1 = np.linspace(1,8.75,12).reshape(3,4) # a1 is 3 x 4 array
a1
Out[21]:
In [22]:
b1 = np.linspace(1,4,4) # b1 is 1 x 4 array
b1
Out[22]:
In [23]:
a1*b1
Out[23]:
It is possible to operate this a1 with b1 as one of part of the array (the column) is equivalent in size.
| array | row | column |
|---|---|---|
| a1 | $$3$$ | $$4$$ |
| b1 | $$1$$ | $$4$$ |
Let c1 be a 1 x 3 array:
In [24]:
c1 = np.linspace(1,3,3)
c1
Out[24]:
In [25]:
a1*c1
The interpreter produces an error as neither row nor column of a1 is equivalent to c1.
| array | row | column |
|---|---|---|
| a1 | $$3$$ | $$4$$ |
| c1 | $$1$$ | $$3$$ |
It is still possible to operate a1 with c1. This can be done by transposing a1 (a1 now becomes 4 x 3 array, so the column size is the same as c1 column size).
In [26]:
a1.T*c1
Out[26]:
Other type of arrays are array with ones and zeroes. These are flexible arrays and can be used for many purposes e.g. indexing collision particles in two dimensions. There is also the $mgrid$ function that is similar to meshgrid in MATLAB.
In [27]:
y = np.ones((10,10))
print y
z = np.zeros((5,5))
print z
In [28]:
i, j = np.mgrid[0:4, 0:4] # similar to meshgrid in MATLAB
In [29]:
i
Out[29]:
In [30]:
j
Out[30]:
In [31]:
m, n = np.mgrid[0:10, 0:10]
(m > n)*1
Out[31]:
$NumPy$ array can be sliced, extracted and reassigned similar to the operations on Python sequences.
In [32]:
# Slicing
x = np.linspace(0,2*np.pi,20)
print x
print x[3:5]
In [33]:
y = np.arange(15).reshape(3,5)
print y
print y[1] # the whole row of index 1
In [34]:
z = y[0:2,1:4] # assigning to variable
z
Out[34]:
In [35]:
y[0:2,1:4] = 0 # reassigned
y
Out[35]:
In [36]:
# reassigned with new array
y[0:2,1:4] = np.array([[45,89,12],[12,73,69]])
y
Out[36]:
There are many other ways to create $NumPy$ array, some are quite fancy e.g.:
In [37]:
X = np.array([n**np.e for n in range(5)]) # note: np.e represent exponential constant
X
Out[37]:
In [38]:
# i is row index and j is column index
W = np.array([[j+i*3 for j in range(3)] for i in range(3)])
W
Out[38]:
$NumPy$ array can be saved into a binary file which later can be loaded. 1-D and 2-D arrays can also be saved in text format.
In [39]:
'''Let us build a 3-dimensional 5 x 5 x 5 array
containing elements created using random number'''
rand_array = np.random.rand(4,4,4)
rand_array
Out[39]:
(The default random number generator algorithm is Mersenne-Twister)
In [40]:
np.save("Tutorial6/random_3D_array.npy", rand_array)
In [41]:
np.load("Tutorial6/random_3D_array.npy")
Out[41]:
In [42]:
rand2_array = np.random.rand(4,4)
The coming examples show how to save array into text file.
In [43]:
np.savetxt("Tutorial6/random_2D_array.txt", rand2_array, delimiter=',')
In the above example, the array _rand2array is saved as comma separated values by specifying comma as the delimiter used.
In [44]:
fh_csv = open("Tutorial6/random_2D_array.txt")
fh_csvList = fh_csv.readlines()
fh_csvList
Out[44]:
It is possible to specify or formatted the decimal value when saving a text file.
In [45]:
np.savetxt("Tutorial6/random_2D_arrayF.txt", rand2_array, \
delimiter=',', fmt='%.3f')
In [46]:
fh_csv1 = open("Tutorial6/random_2D_arrayF.txt")
fh_csv1List = fh_csv1.readlines()
fh_csv1List
Out[46]:
Similar with binary file, a text file can be loaded as an array with delimiter used specified.
In [47]:
fromtxtFile = np.loadtxt("Tutorial6/random_2D_arrayF.txt", delimiter=',')
In [48]:
fromtxtFile
Out[48]:
What we have seen previously were scalar array operations. $NumPy$ array can also undergoes matrix operations. $NumPy$ has special functions for matrix operations.
In [49]:
# Creating two arrays with random numbers, M1 and M2
M1 = np.random.rand(3,3)*np.linspace(1,36,9).reshape(3,3)
M2 = np.random.rand(3,3)*np.linspace(1,2*np.e,9).reshape(3,3)
M1, M2
Out[49]:
In [50]:
# dot product
np.dot(M1,M2)
Out[50]:
In [51]:
N1 = np.arange(2,8,2)
N1
Out[51]:
In [52]:
np.dot(M1,N1)
Out[52]:
In [53]:
np.dot(N1,N1)
Out[53]:
Standard arithmetic operators (+, -, *) can be used for matrix operations by casting the $NumPy$ array as of type matrix.
In [54]:
W1 = np.matrix(M1)
W1
Out[54]:
In [55]:
Y = np.matrix(N1).T
Y
Out[55]:
In [56]:
W2 = np.matrix(M2)
W1*W2 # instead of using np.dot() function
Out[56]:
Matrix operations must adhered to standard matrix agebra and it is good practice to check the shape of the matrices before any operations.
In [57]:
np.shape(W1), np.shape(Y)
Out[57]:
In [58]:
Y + W1*Y
Out[58]:
A few others mathematical functions on matrix include:
In [59]:
# Finding determinant
np.linalg.det(W1)
Out[59]:
In [60]:
# Inverse matrix
np.linalg.inv(W1)
Out[60]:
In [61]:
np.linalg.inv(W1)*W1
Out[61]:
This tutorial part just shows the small fraction on $NumPy$ capabilities so that users will familiarize with the syntax. More on $NumPy$ can be found on: